package com.free.space.common;

import java.lang.reflect.Method;
import java.math.BigDecimal;
import java.util.Collections;
import java.util.Comparator;
import java.util.Date;
import java.util.List;

/**
 * 饮片处方接口通用工具类
 */
public class CommonTool {
    /**
     * 根据字符串排序
     * @param list 需排序的list 内容需是字符串类型
     */
    public static void sortByString(List<String> list) {
        Collections.sort(list, new Comparator() {
            char[] tmp1;
            char[] tmp2;
            String tmpStr;

            @Override
            public int compare(Object o1, Object o2) {
                try {
                    tmpStr = (String) o1;
                    tmp1 = tmpStr.toCharArray();
                    tmpStr = (String) o2;
                    tmp2 = tmpStr.toCharArray();
                } catch (Exception e) {
                    e.printStackTrace();
                }
                return sort(tmp1, tmp2);
            }
        });
    }

    /**
     * 根据对象内，指定字符串排序
     * @param list 需要排序的集合
     * @param str （getXXX） 要排序的字段内容获取方法
     */
    public static void sortByString(List list, String str) {
        Collections.sort(list, new Comparator() {
            char[] tmp1;
            char[] tmp2;
            String tmpStr;

            @Override
            public int compare(Object o1, Object o2) {
                Class clazz = o1.getClass();
                Method m = null;
                try {
                    m = clazz.getMethod(str);
                    tmpStr = (String) m.invoke(o1);
                    tmp1 = tmpStr.toCharArray();
                    tmpStr = (String) m.invoke(o2);
                    tmp2 = tmpStr.toCharArray();
                } catch (Exception e) {
                    e.printStackTrace();
                }
                return sort(tmp1, tmp2);
            }
        });
    }

    /**
     * 字符串转 BigDecimal
     * @param str 需要转成 BigDecimal 类型的字符串
     * @return 转换后的结果
     */
    public static BigDecimal strToBigDecimal(String str) {
        if (null == str || "".equals(str)) {
            return null;
        }
        return new BigDecimal(str);
    }

    /**
     * 字符串转 BigDecimal
     * @param strObj 需要转成 BigDecimal 类型的 Object 对象
     * @return 转换完成的 数据
     */
    public static BigDecimal strToBigDecimal(Object strObj) {
        if (null == strObj) {
            return null;
        }
        return new BigDecimal(strObj.toString());
    }

    /**
     * object to 字符
     * @param strObj  需要转换的对象
     * @return 转换完成的 数据
     */
    public static String objToString(Object strObj) {
        if (null == strObj) {
            return null;
        }
        return strObj.toString();
    }

    /**
     * 字符串转 integer
     *
     * @param str 需要转换的字符串
     * @return 转换完成的 数据
     */
    public static Integer strToInteger(String str) {
        if (null == str) {
            return null;
        }
        return Integer.parseInt(str);
    }

    /**
     * 字符串转 integer
     * @param str 需要转换的对象
     * @return 转换完成的 数据
     */
    public static Integer strToInteger(Object str) {
        if (null == str) {
            return null;
        }
        return Integer.parseInt(str.toString());
    }

    /**
     * 将 java.sql.Timestamp 转换成date
     * @param timestamp 需要转换的对象
     * @return 转换完成的 数据
     */
    public static Date timestamp2Date(Object timestamp) {
        Date date = null;
        if (null != timestamp) {
            long l = ((java.sql.Timestamp) timestamp).getTime();
            date = new Date(l);
        }
        return date;
    }

    /**
     * 将 java.sql.Date 转换成date
     *
     * @param timestamp 需要转换的对象
     * @return 转换完成的 数据
     */
    public static Date sqlDate2Date(Object timestamp) {
        Date date = null;
        if (null != timestamp) {
            long l = ((java.sql.Date) timestamp).getTime();
            date = new Date(l);
        }
        return date;
    }

    /**
     * 字符逐个比较
     * @param tmp1 需要比较的参数
     * @param tmp2 需要比较的参数
     * @return 比较结果 0 相等，1 大于 -1 小于
     */
    private static int sort(char[] tmp1, char[] tmp2) {
        for (int i = 0; i < tmp1.length; i++) {
            if (tmp2.length - 1 < i) {
                return 1;
            }
            if (tmp1[i] > tmp2[i]) {
                return 1;
            } else if (tmp1[i] < tmp2[i]) {
                return -1;
            }
        }
        if (tmp2.length > tmp1.length) {
            return -1;
        }
        return 0;
    }

    /**
     * list 转字符串，‘，’ 分割
     * @param list 需要拼接的数据
     * @param method  属性 获取方法
     * @return
     */
    public static synchronized String list2Str(List list, String method) {
        if (null == list || list.size() == 0) {
            return "";
        }
        String str = "";
        StringBuilder stringBuilder = new StringBuilder();
        for (Object obj : list) {
            Class clazz = obj.getClass();
            try {
                Method m = clazz.getMethod(method);
                str = (String) m.invoke(obj);
                stringBuilder.append(str);
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
        return stringBuilder.toString();
    }

    /**
     * 类型转换
     * @param obj
     * @param <T>
     * @return 转换完成的 数据
     */
    @SuppressWarnings("unchecked")
    public static <T> T cast(Object obj) {
        if(null == obj){
            return null;
        }
        return (T) obj;
    }
}
